home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / quotaops.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  9.8 KB  |  367 lines
  1. /*
  2.  * Definitions for diskquota-operations. When diskquota is configured these
  3.  * macros expand to the right source-code.
  4.  *
  5.  * Author:  Marco van Wieringen <mvw@planets.elm.net>
  6.  */
  7. #ifndef _LINUX_QUOTAOPS_
  8. #define _LINUX_QUOTAOPS_
  9.  
  10. #include <linux/smp_lock.h>
  11. #include <linux/fs.h>
  12.  
  13. static inline struct quota_info *sb_dqopt(struct super_block *sb)
  14. {
  15.     return &sb->s_dquot;
  16. }
  17.  
  18. #if defined(CONFIG_QUOTA)
  19.  
  20. /*
  21.  * declaration of quota_function calls in kernel.
  22.  */
  23. void sync_dquots(struct super_block *sb, int type);
  24.  
  25. int dquot_initialize(struct inode *inode, int type);
  26. int dquot_drop(struct inode *inode);
  27.  
  28. int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
  29. int dquot_alloc_inode(const struct inode *inode, unsigned long number);
  30.  
  31. int dquot_free_space(struct inode *inode, qsize_t number);
  32. int dquot_free_inode(const struct inode *inode, unsigned long number);
  33.  
  34. int dquot_transfer(struct inode *inode, struct iattr *iattr);
  35. int dquot_commit(struct dquot *dquot);
  36. int dquot_acquire(struct dquot *dquot);
  37. int dquot_release(struct dquot *dquot);
  38. int dquot_commit_info(struct super_block *sb, int type);
  39. int dquot_mark_dquot_dirty(struct dquot *dquot);
  40.  
  41. int vfs_quota_on(struct super_block *sb, int type, int format_id,
  42.      char *path, int remount);
  43. int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
  44.      struct path *path);
  45. int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
  46.      int format_id, int type);
  47. int vfs_quota_off(struct super_block *sb, int type, int remount);
  48. int vfs_quota_sync(struct super_block *sb, int type);
  49. int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  50. int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  51. int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  52. int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  53.  
  54. void vfs_dq_drop(struct inode *inode);
  55. int vfs_dq_transfer(struct inode *inode, struct iattr *iattr);
  56. int vfs_dq_quota_on_remount(struct super_block *sb);
  57.  
  58. static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
  59. {
  60.     return sb_dqopt(sb)->info + type;
  61. }
  62.  
  63. /*
  64.  * Functions for checking status of quota
  65.  */
  66.  
  67. static inline int sb_has_quota_enabled(struct super_block *sb, int type)
  68. {
  69.     if (type == USRQUOTA)
  70.         return sb_dqopt(sb)->flags & DQUOT_USR_ENABLED;
  71.     return sb_dqopt(sb)->flags & DQUOT_GRP_ENABLED;
  72. }
  73.  
  74. static inline int sb_any_quota_enabled(struct super_block *sb)
  75. {
  76.     return sb_has_quota_enabled(sb, USRQUOTA) ||
  77.         sb_has_quota_enabled(sb, GRPQUOTA);
  78. }
  79.  
  80. static inline int sb_has_quota_suspended(struct super_block *sb, int type)
  81. {
  82.     if (type == USRQUOTA)
  83.         return sb_dqopt(sb)->flags & DQUOT_USR_SUSPENDED;
  84.     return sb_dqopt(sb)->flags & DQUOT_GRP_SUSPENDED;
  85. }
  86.  
  87. static inline int sb_any_quota_suspended(struct super_block *sb)
  88. {
  89.     return sb_has_quota_suspended(sb, USRQUOTA) ||
  90.         sb_has_quota_suspended(sb, GRPQUOTA);
  91. }
  92.  
  93. /*
  94.  * Operations supported for diskquotas.
  95.  */
  96. extern struct dquot_operations dquot_operations;
  97. extern struct quotactl_ops vfs_quotactl_ops;
  98.  
  99. #define sb_dquot_ops (&dquot_operations)
  100. #define sb_quotactl_ops (&vfs_quotactl_ops)
  101.  
  102. /* It is better to call this function outside of any transaction as it might
  103.  * need a lot of space in journal for dquot structure allocation. */
  104. static inline void vfs_dq_init(struct inode *inode)
  105. {
  106.     BUG_ON(!inode->i_sb);
  107.     if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode))
  108.         inode->i_sb->dq_op->initialize(inode, -1);
  109. }
  110.  
  111. /* The following allocation/freeing/transfer functions *must* be called inside
  112.  * a transaction (deadlocks possible otherwise) */
  113. static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
  114. {
  115.     if (sb_any_quota_enabled(inode->i_sb)) {
  116.         /* Used space is updated in alloc_space() */
  117.         if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
  118.             return 1;
  119.     }
  120.     else
  121.         inode_add_bytes(inode, nr);
  122.     return 0;
  123. }
  124.  
  125. static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
  126. {
  127.     int ret;
  128.         if (!(ret =  vfs_dq_prealloc_space_nodirty(inode, nr)))
  129.         mark_inode_dirty(inode);
  130.     return ret;
  131. }
  132.  
  133. static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
  134. {
  135.     if (sb_any_quota_enabled(inode->i_sb)) {
  136.         /* Used space is updated in alloc_space() */
  137.         if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
  138.             return 1;
  139.     }
  140.     else
  141.         inode_add_bytes(inode, nr);
  142.     return 0;
  143. }
  144.  
  145. static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
  146. {
  147.     int ret;
  148.     if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
  149.         mark_inode_dirty(inode);
  150.     return ret;
  151. }
  152.  
  153. static inline int vfs_dq_alloc_inode(struct inode *inode)
  154. {
  155.     if (sb_any_quota_enabled(inode->i_sb)) {
  156.         vfs_dq_init(inode);
  157.         if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
  158.             return 1;
  159.     }
  160.     return 0;
  161. }
  162.  
  163. static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
  164. {
  165.     if (sb_any_quota_enabled(inode->i_sb))
  166.         inode->i_sb->dq_op->free_space(inode, nr);
  167.     else
  168.         inode_sub_bytes(inode, nr);
  169. }
  170.  
  171. static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
  172. {
  173.     vfs_dq_free_space_nodirty(inode, nr);
  174.     mark_inode_dirty(inode);
  175. }
  176.  
  177. static inline void vfs_dq_free_inode(struct inode *inode)
  178. {
  179.     if (sb_any_quota_enabled(inode->i_sb))
  180.         inode->i_sb->dq_op->free_inode(inode, 1);
  181. }
  182.  
  183. /* The following two functions cannot be called inside a transaction */
  184. static inline void vfs_dq_sync(struct super_block *sb)
  185. {
  186.     sync_dquots(sb, -1);
  187. }
  188.  
  189. static inline int vfs_dq_off(struct super_block *sb, int remount)
  190. {
  191.     int ret = -ENOSYS;
  192.  
  193.     if (sb->s_qcop && sb->s_qcop->quota_off)
  194.         ret = sb->s_qcop->quota_off(sb, -1, remount);
  195.     return ret;
  196. }
  197.  
  198. #else
  199.  
  200. static inline int sb_has_quota_enabled(struct super_block *sb, int type)
  201. {
  202.     return 0;
  203. }
  204.  
  205. static inline int sb_any_quota_enabled(struct super_block *sb)
  206. {
  207.     return 0;
  208. }
  209.  
  210. static inline int sb_has_quota_suspended(struct super_block *sb, int type)
  211. {
  212.     return 0;
  213. }
  214.  
  215. static inline int sb_any_quota_suspended(struct super_block *sb)
  216. {
  217.     return 0;
  218. }
  219.  
  220. /*
  221.  * NO-OP when quota not configured.
  222.  */
  223. #define sb_dquot_ops                (NULL)
  224. #define sb_quotactl_ops                (NULL)
  225.  
  226. static inline void vfs_dq_init(struct inode *inode)
  227. {
  228. }
  229.  
  230. static inline void vfs_dq_drop(struct inode *inode)
  231. {
  232. }
  233.  
  234. static inline int vfs_dq_alloc_inode(struct inode *inode)
  235. {
  236.     return 0;
  237. }
  238.  
  239. static inline void vfs_dq_free_inode(struct inode *inode)
  240. {
  241. }
  242.  
  243. static inline void vfs_dq_sync(struct super_block *sb)
  244. {
  245. }
  246.  
  247. static inline int vfs_dq_off(struct super_block *sb, int remount)
  248. {
  249.     return 0;
  250. }
  251.  
  252. static inline int vfs_dq_quota_on_remount(struct super_block *sb)
  253. {
  254.     return 0;
  255. }
  256.  
  257. static inline int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
  258. {
  259.     return 0;
  260. }
  261.  
  262. static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
  263. {
  264.     inode_add_bytes(inode, nr);
  265.     return 0;
  266. }
  267.  
  268. static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
  269. {
  270.     vfs_dq_prealloc_space_nodirty(inode, nr);
  271.     mark_inode_dirty(inode);
  272.     return 0;
  273. }
  274.  
  275. static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
  276. {
  277.     inode_add_bytes(inode, nr);
  278.     return 0;
  279. }
  280.  
  281. static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
  282. {
  283.     vfs_dq_alloc_space_nodirty(inode, nr);
  284.     mark_inode_dirty(inode);
  285.     return 0;
  286. }
  287.  
  288. static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
  289. {
  290.     inode_sub_bytes(inode, nr);
  291. }
  292.  
  293. static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
  294. {
  295.     vfs_dq_free_space_nodirty(inode, nr);
  296.     mark_inode_dirty(inode);
  297. }    
  298.  
  299. #endif /* CONFIG_QUOTA */
  300.  
  301. static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
  302. {
  303.     return vfs_dq_prealloc_space_nodirty(inode,
  304.             nr << inode->i_sb->s_blocksize_bits);
  305. }
  306.  
  307. static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
  308. {
  309.     return vfs_dq_prealloc_space(inode,
  310.             nr << inode->i_sb->s_blocksize_bits);
  311. }
  312.  
  313. static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
  314. {
  315.      return vfs_dq_alloc_space_nodirty(inode,
  316.             nr << inode->i_sb->s_blocksize_bits);
  317. }
  318.  
  319. static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
  320. {
  321.     return vfs_dq_alloc_space(inode,
  322.             nr << inode->i_sb->s_blocksize_bits);
  323. }
  324.  
  325. static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
  326. {
  327.     vfs_dq_free_space_nodirty(inode, nr << inode->i_sb->s_blocksize_bits);
  328. }
  329.  
  330. static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
  331. {
  332.     vfs_dq_free_space(inode, nr << inode->i_sb->s_blocksize_bits);
  333. }
  334.  
  335. /*
  336.  * Define uppercase equivalents for compatibility with old function names
  337.  * Can go away when we think all users have been converted (15/04/2008)
  338.  */
  339. #define DQUOT_INIT(inode) vfs_dq_init(inode)
  340. #define DQUOT_DROP(inode) vfs_dq_drop(inode)
  341. #define DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr) \
  342.                 vfs_dq_prealloc_space_nodirty(inode, nr)
  343. #define DQUOT_PREALLOC_SPACE(inode, nr) vfs_dq_prealloc_space(inode, nr)
  344. #define DQUOT_ALLOC_SPACE_NODIRTY(inode, nr) \
  345.                 vfs_dq_alloc_space_nodirty(inode, nr)
  346. #define DQUOT_ALLOC_SPACE(inode, nr) vfs_dq_alloc_space(inode, nr)
  347. #define DQUOT_PREALLOC_BLOCK_NODIRTY(inode, nr) \
  348.                 vfs_dq_prealloc_block_nodirty(inode, nr)
  349. #define DQUOT_PREALLOC_BLOCK(inode, nr) vfs_dq_prealloc_block(inode, nr)
  350. #define DQUOT_ALLOC_BLOCK_NODIRTY(inode, nr) \
  351.                 vfs_dq_alloc_block_nodirty(inode, nr)
  352. #define DQUOT_ALLOC_BLOCK(inode, nr) vfs_dq_alloc_block(inode, nr)
  353. #define DQUOT_ALLOC_INODE(inode) vfs_dq_alloc_inode(inode)
  354. #define DQUOT_FREE_SPACE_NODIRTY(inode, nr) \
  355.                 vfs_dq_free_space_nodirty(inode, nr)
  356. #define DQUOT_FREE_SPACE(inode, nr) vfs_dq_free_space(inode, nr)
  357. #define DQUOT_FREE_BLOCK_NODIRTY(inode, nr) \
  358.                 vfs_dq_free_block_nodirty(inode, nr)
  359. #define DQUOT_FREE_BLOCK(inode, nr) vfs_dq_free_block(inode, nr)
  360. #define DQUOT_FREE_INODE(inode) vfs_dq_free_inode(inode)
  361. #define DQUOT_TRANSFER(inode, iattr) vfs_dq_transfer(inode, iattr)
  362. #define DQUOT_SYNC(sb) vfs_dq_sync(sb)
  363. #define DQUOT_OFF(sb, remount) vfs_dq_off(sb, remount)
  364. #define DQUOT_ON_REMOUNT(sb) vfs_dq_quota_on_remount(sb)
  365.  
  366. #endif /* _LINUX_QUOTAOPS_ */
  367.